//参考：
//http://www.runoob.com/java/java-regular-expressions.html
//https://www.cnblogs.com/GarfieldEr007/p/7050952.html
//https://www.cnblogs.com/lzq198754/p/5780340.html

package c03正则表达式;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.junit.Test;

public class MainTest {

	@Test
	public void 简单使用() throws Exception {

		//要检索的内容字符串
		String content = "I am noob " + "from runoob.com.";
		//按这个模式查找字符串中匹配的项
		String pattern = ".*runoob.*";

		//1、一次性匹配
		boolean isMatch = Pattern.matches(pattern, content);
		System.err.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);

		//2.1、Pattern 对象是一个正则表达式的编译表示，没有公共构造方法，应该这样创建 Pattern 对象
		Pattern r = Pattern.compile(pattern);
		//2.2、Matcher 对象是对输入字符串进行解释和匹配操作的引擎，也没有公共构造方法，这样创建 matcher 对象
		Matcher m = r.matcher(content);
		//可多次匹配
		if (m.find()) {
			System.err.println("Found value: " + m.group(0));
		} else {
			System.err.println("NO MATCH");
		}

	}


	@Test
	public void 限定字符() {
		/*
		 * \：将下一字符标记为特殊字符、文本、反向引用或八进制转义符。
		 * 在其他语言中，\\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。
		 * 在 Java 中，\\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
		 * 所以，在其他的语言中，一个反斜杠\就足以具有转义的作用，而在正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。
		 * 也可以简单的理解在正则表达式中，两个 \ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \\d，而表示一个普通的反斜杠是 \\\\。
		 */
		System.err.println(Pattern.matches("x\\.y", "x.y"));

		//^：在开头匹配正则。当^是[]中的第一个字符时代表取反，例如 [^abc] 匹配除了a,b或c之外的任意字符
		System.err.println(Pattern.matches("^x", "x.y")); //f
		System.err.println(Pattern.matches("^a.*", "abcd")); //t
		System.err.println(Pattern.matches("^a.*", "xabcd")); //f，因为不是以a开头

		//$：在结尾匹配正则（例子参考上面）

		//.：匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。

		//*：零次或多次匹配星号前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。
		//+：一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
		/*
		 * ?：零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。
		 * 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。
		 * "非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。
		 * 例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。
		 */

		//|：或，例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"
		System.err.println(Pattern.matches(".*z|food.*", "food")); //t
		System.err.println(Pattern.matches(".*(z|f)ood.*", "food")); //t
		System.err.println(Pattern.matches(".*(z|f)ood.*", "kood")); //f
	}

	@Test
	public void 元字符() {
		/*
		 * \d：数字字符匹配。等效于 [0-9]。
		 * \D：非数字字符匹配。等效于 [^0-9]。规律：大写与小写的功能刚好相反，下面以此类推。
		 *
		 * \s：匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
		 * \S：~
		 *
		 * \w：匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
		 * \W：~
		 *
		 * \b：匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
		 * \B：~例如，"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
		 *
		 * \f：换页符匹配。等效于 \x0c 和 \cL。
		 *
		 * \n：换行符匹配。等效于 \x0a 和 \cJ。
		 * \r：匹配一个回车符。等效于 \x0d 和 \cM。
		 *
		 * \t：制表符匹配。与 \x09 和 \cI 等效。
		 * \v：垂直制表符匹配。与 \x0b 和 \cK 等效。
		 */

	}

	@Test
	public void 组合字符模式() {
		/*
		 * \d：数字字符匹配。等效于 [0-9]。
		 * \D：非数字字符匹配。等效于 [^0-9]。规律：大写与小写的功能刚好相反，下面以此类推。
		 *
		 * \s：匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
		 * \S：~
		 *
		 * \w：匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
		 * \W：~
		 *
		 * \b：匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
		 * \B：~例如，"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
		 *
		 * \f：换页符匹配。等效于 \x0c 和 \cL。
		 *
		 * \n：换行符匹配。等效于 \x0a 和 \cJ。
		 * \r：匹配一个回车符。等效于 \x0d 和 \cM。
		 *
		 * \t：制表符匹配。与 \x09 和 \cI 等效。
		 * \v：垂直制表符匹配。与 \x0b 和 \cK 等效。
		 */

	}

	/**
	 * 限定前面的字符或子表达式出现次数
	 * <br><br>
	 * 创建人： 袁炜林 <br>
	 * 创建时间：  2018年3月1日 下午6:28:15 <br>
	 */
	@Test
	public void 大括号() {
		//X{n}：X正好出现n次，n、m皆是正整数
		System.err.println(Pattern.matches("o{2}", "o")); //f
		System.err.println(Pattern.matches("o{2}", "oo")); //t
		System.err.println(Pattern.matches("o{2}", "ooo")); //f

		//X{n,}：X出现 >= n次
		System.err.println(Pattern.matches("o{2,}", "o")); //f
		System.err.println(Pattern.matches("o{2,}", "oo")); //t
		System.err.println(Pattern.matches("o{2,}", "ooo")); //t

		//X{n,m}：X出现 >= n 并且 <=m 次
		System.err.println(Pattern.matches("o{1,2}", "o")); //t
		System.err.println(Pattern.matches("o{1,2}", "oo")); //t
		System.err.println(Pattern.matches("o{1,2}", "ooo")); //f

	}

	/**
	 * 字符集匹配
	 * <br><br>
	 * 创建人： 袁炜林 <br>
	 * 创建时间：  2018年3月1日 下午6:30:58 <br>
	 */
	@Test
	public void 中括号() {
		//[xyz]：匹配x、y或z，"[abc]"匹配"plain"中的"a"。
		System.err.println(Pattern.matches(".*[abc].*", "plain")); //t

		//[^xyz]：匹配除了 x、y或z 之外的任意字符，例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
		/*
		 *  [a-e1-8]：匹配a到e或者1到8之间的字符，例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
		 *  注意：只有连字符在字符组内部时，并且出现在两个字符之间时,才能表示字符的范围； 如果出字符组的开头,则只能表示连字符本身。
		 */
		//[^a-z]：匹配不在指定的范围内的任何字符，例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。

		//[abc][12]：能够匹配由1或2跟着的a,b或c
		System.err.println(Pattern.matches(".*[abc][12].*", "xc21")); //t
		System.err.println(Pattern.matches(".*[abc][12].*", "xc31")); //f

//		System.err.println(Pattern.matches("^[A-Fa-f0-9]+$", null)); //NullPointerException
		System.err.println("123abcf".matches("^[A-Fa-f0-9]+$")); //t
	}

	/**
	 * 小括号代表捕获组，是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建，可以捕获分组里的内容
	 * <br><br>
	 * 创建人： 袁炜林 <br>
	 * 创建时间：  2018年3月1日 下午6:45:06 <br>
	 */
	@Test
	public void 小括号() {
		String line = "This order was placed for QT3000! OK?";
		String pattern = "(\\D*)(\\d+)(.*)"; //捕获组是通过从左至右计算其开括号来编号（下标从1开始），这个表达式有这几个组：(\\D*)，(\\d+)，(.*)

		Pattern r = Pattern.compile(pattern);
		Matcher m = r.matcher(line);

		if (m.find()) {
			System.err.println("groupCount：" + m.groupCount()); //查看表达式有多少个分组，不包含group(0)
			System.err.println("group(0): " + m.group(0)); //group(0)总是代表整个表达式，这里等价于 (\\D*)(\\d+)(.*)
			System.err.println("group(): " + m.group()); //group() 等价于 group(0)
			System.err.println("group(1): " + m.group(1)); //获取第一个分组 (\\D*) 里的内容 \\D*，下面以此类推
			System.err.println("group(2): " + m.group(2));
			System.err.println("group(3): " + m.group(3));
		} else {
			System.err.println("NO MATCH");
		}
	}

	@Test
	public void 捕获组测试() {
		String line = "<p><image alt=\"\" src=\"http://n.sinaimg.cn/tech/transform/247/w630h417/20180509/VO13-haichqz0258654.jpg\" /></p>\r\n";
		String pattern = ".*(http.+\\.(png|jpg|jpeg|bmp)).*"; //捕获组是通过从左至右计算其开括号来编号（下标从1开始），这个表达式有这几个组：(\\D*)，(\\d+)，(.*)

		Pattern r = Pattern.compile(pattern);
		Matcher m = r.matcher(line);

		if (m.find()) {
			System.err.println("groupCount：" + m.groupCount()); //查看表达式有多少个分组，不包含group(0)
			System.err.println("group(0): " + m.group(0)); //group(0)总是代表整个表达式，这里等价于 (\\D*)(\\d+)(.*)
			System.err.println("group(): " + m.group()); //group() 等价于 group(0)
			System.err.println("group(1): " + m.group(1)); //获取第一个分组 (\\D*) 里的内容 \\D*，下面以此类推
			System.err.println("group(2): " + m.group(2));
//			System.err.println("group(3): " + m.group(3));
		} else {
			System.err.println("NO MATCH");
		}
	}

}
